import { LakalaContractEntity } from './../../entity/lakala_contract';
import {
  Controller,
  Post,
  Get,
  Body,
  Query,
  Inject,
  Files,
  Fields,
  File,
} from '@midwayjs/core';
import { LakalaConfig } from '../../utils/config/lakala';
import { LakalaUtils } from '../../utils/lakala';
import { LakalaMerchantService } from '../../service/lakala-merchant';
import { CoolTag, TagTypes } from '@cool-midway/core';
import moment = require('moment');
import { client_id, client_secret } from '../../constant';
import { Context } from '@midwayjs/koa';
import { InjectEntityModel } from '@midwayjs/typeorm';
import { Repository } from 'typeorm';
import axios from 'axios';
import FormData = require('form-data');
import { Utils } from '../../../../comm/utils';
import * as fs from 'fs';

/**
 * 拉卡拉商户进件前端控制器
 */
@Controller('/app/lakala/merchant')
export class AppLakalaMerchantController {
  @Inject()
  lakalaMerchantService: LakalaMerchantService;

  @Inject()
  ctx: Context;

  @InjectEntityModel(LakalaContractEntity)
  contractModel: Repository<LakalaContractEntity>;

  @Inject()
  commonUtils: Utils;

  private readonly utils = new LakalaUtils();

  /* 获取地区信息 */
  @Get('/areaList')
  async queryAreaList() {
    /* 获取 get请求参数 */
    const query = this.ctx.query;

    try {
      const result = await this.lakalaMerchantService.getAreaList(
        query?.parentCode
      );
      return {
        success: true,
        message: result ? '查询地区信息成功' : result.error,
        data: result,
        code: 1000,
      };
    } catch (error) {
      console.log('error', error);
      return {
        success: false,
        message: '系统错误，请稍后重试',
      };
    }
  }

  /* 获取银行列表 */
  @Get('/bankList')
  async queryBankList() {
    /* 获取 get请求参数 */
    const query = this.ctx.query;

    console.log('queryqueryqueryqueryquery', query?.parentCode);

    try {
      const result = await this.lakalaMerchantService.getBankList(
        query?.parentCode
      );
      return {
        success: true,
        message: result ? '查询银行列表成功' : result.error,
        data: result,
        code: 1000,
      };
    } catch (error) {
      console.log('error', error);
      return {
        success: false,
        message: '系统错误，请稍后重试',
      };
    }
  }

  /* 获取银行地区信息 */
  @Get('/bankAreaList')
  async queryBankAreaList() {
    /* 获取 get请求参数 */
    const query = this.ctx.query;
    try {
      const result = await this.lakalaMerchantService.getBankAreaList(
        query?.parentCode
      );
      return {
        success: true,
        message: result ? '查询地区信息成功' : result.error,
        data: result,
        code: 1000,
      };
    } catch (error) {
      console.log('error', error);
      return {
        success: false,
        message: '系统错误，请稍后重试',
      };
    }
  }

  /**
   * 商户进件申请
   */
  @Post('/apply')
  async applyMerchant(@Body() body: any) {
    const applicationData = body;

    /* 随机订单号 */
    const order_no = `${moment().format('YYYYMMDDHHmmss')}${Math.floor(
      Math.random() * 100000000
    )}`;

    if (!applicationData?.ecNo) {
      return {
        success: false,
        message: '电子合同编号不能为空',
      };
    }

    try {
      const _body = {
        // 固定
        userNo: 24371029,
        // 邮箱
        email: applicationData?.email, //
        // 固定的
        busiCode: 'WECHAT_PAY',
        /* 4-7位 */
        merRegName: applicationData?.merRegName, //
        // TP_MERCHANT:企业 TP_PERSONAL:⼩微个⼈
        merType: 'TP_PERSONAL',
        // 不能少于七个中文
        merName: applicationData?.merName, //
        // 去掉省，市区后的详细地址
        merAddr: applicationData?.merAddr,
        // 通过【地区信息→获取地区查询】接口获取 对应 code字段
        provinceCode: applicationData?.provinceCode,
        /* 通过【地区信息→获取地区查询】接口获取 对应 code字段 */
        cityCode: applicationData?.cityCode,
        // 通过【地区信息→获取地区查询】接口获取 对应 code字段
        countyCode: applicationData?.countyCode,
        latitude: 1,
        longtude: 2,
        source: 'H5',
        businessContent: '电玩店',
        /* 法⼈姓名  */
        larName: applicationData?.larName, //
        larIdType: '01',
        larIdCard: applicationData?.larIdCard, //
        larIdCardStart: applicationData?.larIdCardStart, //
        larIdCardEnd: applicationData?.larIdCardEnd, //
        /* 商户联系人手机号 */
        contactMobile: applicationData?.contactMobile, //
        // 商户联系⼈姓名，和法人一致
        contactName: applicationData?.larName, //
        // 通过【银行列表查询】接口获取 对应 branchBankNo字段
        openningBankCode: applicationData?.openningBankCode,
        // 通过【银行列表查询】接口获取 对应 branchBankName字段
        openningBankName: applicationData?.openningBankName,
        // 通过【银行列表查询】接口获取 对应 clearNo字段
        clearingBankCode: applicationData?.clearingBankCode,
        // 通过【地区信息→获取银行地区查询】接口获取 对应 code字段
        settleProvinceCode: applicationData?.settleProvinceCode,
        // 通过【地区信息→获取银行地区查询】接口获取 对应 name字段
        settleProvinceName: applicationData?.settleProvinceName,
        // 通过【地区信息→获取银行地区查询】接口获取 对应 code字段
        settleCityCode: applicationData?.settleCityCode,
        // 通过【地区信息→获取银行地区查询】接口获取 对应 name字段
        settleCityName: applicationData?.settleCityName,
        // 结算人银行卡
        accountNo: applicationData?.accountNo, //
        // 结算人账户名称，通法人
        accountName: applicationData?.larName, //
        /* 固定 */
        accountType: '58',
        /* 结算⼈证件号码， 通法人身份 */
        accountIdCard: applicationData?.larIdCard, //
        // 业务拓展信息，固定
        bizContent: {
          fees: [
            {
              feeCode: 'WECHAT',
              feeValue: 0.38,
            },
            {
              feeCode: 'ALIPAY',
              feeValue: 0.38,
            },
            {
              feeCode: 'CREDIT_CARD',
              feeValue: 0.6,
            },
            {
              feeCode: 'DEBIT_CARD',
              feeValue: 0.5,
              topFee: 20,
            },
          ],
          mcc: '5943',
          termNum: '1',
          activityId: '208',
        },
        // 结算类型
        settleType: 'D1',
        settlementType: 'AUTOMATIC',
        // 是否法人进件
        isLegalPerson: false,
        /* 自己自定义 */
        externalNo: order_no,
        attchments: applicationData?.attchments,
        // 电子合同编号
        contractNo: applicationData?.ecNo,
      };

      // 提交进件申请
      const result = await this.lakalaMerchantService.applyMerchant(_body);

      console.log('进件结果333333333：', result);

      return {
        success: result.success,
        message: result.success
          ? '商户进件申请提交成功，请等待审核'
          : result.error,
        code: 1000,
        data: result
      };
    } catch (error) {
      console.log('error', error);

      // this.utils.logError('商户进件申请失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试',
      };
    }
  }

  /**
   * 查询商户审核状态
   */
  // @Get('/status')
  // async queryMerchantStatus(@Query() query: { merchantNo: string }) {
  //   try {
  //     const { merchantNo } = query;

  //     if (!merchantNo) {
  //       return {
  //         success: false,
  //         message: '商户号不能为空',
  //       };
  //     }

  //     const tokenResult = await this.lakalaMerchantService.getAccessToken();
  //     if (!tokenResult.success) {
  //       return {
  //         success: false,
  //         message: '获取访问令牌失败：' + tokenResult.error,
  //       };
  //     }

  //     const result = await this.lakalaMerchantService.queryMerchantStatus(
  //       merchantNo,
  //       tokenResult.data.accessToken
  //     );

  //     return {
  //       success: result.success,
  //       message: result.success ? '查询成功' : result.error,
  //       data: result.data
  //         ? {
  //             ...result.data,
  //             statusText: this.utils.formatStatus(
  //               result.data.status,
  //               'merchant'
  //             ),
  //           }
  //         : null,
  //     };
  //   } catch (error) {
  //     this.utils.logError('查询商户状态失败', error);
  //     return {
  //       success: false,
  //       message: '系统错误，请稍后重试',
  //     };
  //   }
  // }

  /**
   * 合同申请
   */
  @Post('/contract/apply')
  async applyContract(@Body() body: any) {
    try {
      if (!body) {
        return {
          success: false,
          message: '合同信息不能为空',
        };
      }

      const { ctx } = this;
      const userId = ctx?.user?.id || undefined; // 获取当前用户ID

      console.log('userIduserIduserId', userId);

      const result = await this.lakalaMerchantService.applyContract(
        body,
        userId
      );

      if (result?.code === '000000') {
        return {
          code: 1000,
          message: '合同申请成功',
          data: result,
        };
      } else {
        return {
          data: result?.data,
          message: result?.msg ? result?.msg : '合同申请失败',
          code: result.code,
        };
      }
    } catch (error) {
      this.utils.logError('合同申请失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试',
      };
    }
  }

  // 合同申请回调
  @CoolTag(TagTypes.IGNORE_TOKEN)
  @Post('/contract/callback')
  async contractCallback(@Body() body: any) {
    console.log('收到合同申请回调=>>>>>', body);

    /* 通过orderNo去合同表查询合同 */
    const contract = await this.contractModel.findOne({
      where: {
        orderNo: body.orderNo,
      },
    });

    console.log('找到对应的合同信息了=>', contract);

    // 更新合同状态
    this.contractModel.update({
      orderNo: body.orderNo,
    }, {
      status: 1,
      failReason: body?.failReason
    })



  }

  // 获取拉卡拉token
  @Get('/getLakalaToken')
  async getToken() {
    const result = await this.lakalaMerchantService.getAccessToken();
    return {
      success: true,
      message: result ? '获取成功' : result.error,
      data: result,
      code: 1000,
    };
  }

  /**
   * 查询合同状态
   */
  @Get('/contract/status')
  async queryContractStatus(@Query() query: { contractNo: string }) {
    try {
      const { contractNo } = query;

      if (!contractNo) {
        return {
          success: false,
          message: '合同号不能为空',
        };
      }

      const tokenResult = await this.lakalaMerchantService.getAccessToken();
      if (!tokenResult.success) {
        return {
          success: false,
          message: '获取访问令牌失败：' + tokenResult.error,
        };
      }

      const result = await this.lakalaMerchantService.queryContractStatus(
        contractNo,
        tokenResult.data.accessToken
      );

      return {
        success: result.success,
        message: result.success ? '查询成功' : result.error,
        data: result.data
          ? {
            ...result.data,
            statusText: this.utils.formatStatus(
              result.data.status,
              'contract'
            ),
          }
          : null,
      };
    } catch (error) {
      this.utils.logError('查询合同状态失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试',
      };
    }
  }

  /**
   * 文件上传
   */
  @Post('/file/upload')
  async uploadFile(
    @Files() files,
    @Fields() fields,
    @Body() body: { file: any; imgType: string; sourcechnl: any }
  ) {
    try {
      console.log('files', files);

      const formData = new FormData();
      // 添加文件到 FormData
      // 第三方接口要求文件字段名必须是'file'
      for (const fieldname in files) {
        const file = files[fieldname];
        // 使用 fs.createReadStream 读取文件内容
        const fileStream = fs.createReadStream(file.data);
        formData.append('file', fileStream, {
          filename: file.filename,
          contentType: file.mimeType,
        });
        break; // 只处理第一个文件，因为拉卡拉接口一次只能上传一个文件
      }

      // 转发所有文本字段
      for (const key in fields) {
        formData.append(key, fields[key]);
      }

      formData.append('isOcr', 'false');

      const tokenResult = await this.lakalaMerchantService.getAccessToken();

      if (!tokenResult) {
        return {
          success: false,
          message: '获取访问令`牌失败',
        };
      }

      console.log('fieldsfieldsfieldsfields', fields);

      const response = await axios.post(
        'https://htkactvi.lakala.com/registration/file/upload',
        formData,
        {
          headers: {
            Authorization: `Bearer ${tokenResult}`,
            ...formData.getHeaders(),
          },
        }
      );

      console.log('上传结果', response.data);

      const result = response.data;

      if (result.status == '00') {
        return {
          success: true,
          message: '文件上传成功',
          data: {
            ...result,
          },
          code: 1000,
        };
      } else {
        return {
          success: false,
          message: '文件上传失败',
          code: result.code,
        };
      }
    } catch (error) {
      this.utils.logError('文件上传失败了吗？', error);
      return {
        success: false,
        message: '系统错误，请稍后重试',
      };
    }
  }

  /**
   * 获取配置信息
   */
  @Get('/config')
  async getConfig() {
    try {
      return {
        success: true,
        message: '获取成功',
        data: {
          merchantTypes: Object.keys(LakalaConfig.MERCHANT_TYPES).map(key => ({
            value: LakalaConfig.MERCHANT_TYPES[key],
            label: this.utils.formatMerchantType(
              LakalaConfig.MERCHANT_TYPES[key]
            ),
          })),
          contractTypes: Object.keys(LakalaConfig.CONTRACT_TYPES).map(key => ({
            value: LakalaConfig.CONTRACT_TYPES[key],
            label: this.utils.formatContractType(
              LakalaConfig.CONTRACT_TYPES[key]
            ),
          })),
          signTypes: Object.keys(LakalaConfig.SIGN_TYPES).map(key => ({
            value: LakalaConfig.SIGN_TYPES[key],
            label: key === 'ELECTRONIC' ? '电子签署' : '纸质签署',
          })),
          fileTypes: Object.keys(LakalaConfig.FILE_TYPES).map(key => ({
            value: LakalaConfig.FILE_TYPES[key],
            label: this.getFileTypeLabel(LakalaConfig.FILE_TYPES[key]),
          })),
          fileConfig: LakalaConfig.getFileConfig(),
        },
      };
    } catch (error) {
      this.utils.logError('获取配置失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试',
      };
    }
  }

  /**
   * 生成商户号
   */
  @Get('/generate/merchant-no')
  async generateMerchantNo() {
    try {
      const merchantNo = this.utils.generateMerchantNo();

      return {
        success: true,
        message: '生成成功',
        data: { merchantNo },
      };
    } catch (error) {
      this.utils.logError('生成商户号失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试',
      };
    }
  }

  /**
   * 获取文件类型标签
   */
  private getFileTypeLabel(fileType: string): string {
    const labelMap = {
      [LakalaConfig.FILE_TYPES.BUSINESS_LICENSE]: '营业执照',
      [LakalaConfig.FILE_TYPES.ID_CARD_FRONT]: '身份证正面',
      [LakalaConfig.FILE_TYPES.ID_CARD_BACK]: '身份证背面',
      [LakalaConfig.FILE_TYPES.BANK_CARD]: '银行卡',
      [LakalaConfig.FILE_TYPES.CHECKSTAND_IMG]: '收银台',
      [LakalaConfig.FILE_TYPES.SHOP_OUTSIDE_IMG]: '门头',
    };

    return labelMap[fileType] || fileType;
  }
  /* 不需要登录 */ /* 查询卡状态 */
  @CoolTag(TagTypes.IGNORE_TOKEN)
  @Post('/cardBin')
  async queryCardBin(@Body() body: { cardBin: string }) {
    console.log('到这里了吗？？？？');

    const _body = {
      reqData: {
        version: '1.0',
        orderNo: '2021020112000012345678',
        orgCode: '984459',
        cardNo: '4275711234554321',
      },
    };

    try {
      // 发送进件申请
      const response = await axios.post(
        // `${this.config.baseUrl}/api/v3/merchant/apply`,
        'https://s2.lakala.com/api/v2/mms/openApi/cardBin',
        _body,
        {
          headers: {
            'Content-Type': 'application/json',
            Accept: 'application/json',
            Authorization: this.commonUtils.createAuthorization(_body),
          },
        }
      );
      console.log('responseresponseresponse', response?.data);
    } catch (e) {
      console.log('请求出错', e);
    }
  }

  /* 查询当前用户是否出于进件中 */
  @Post('/isApplying')
  async isApplying() {
    const userId = this.ctx?.user?.id || undefined; // 获取当前用户ID

    /* 如果有userId，去合同表查询，是否有对应的合同 */
    if (userId) {
      const result = await this.contractModel.findOne({
        where: {
          userId,
        },
        order: {
          id: 'DESC',
        },
      });
      return {
        success: true,
        message: '查询成功',
        data: result,
        code: 1000,
      };
    } else {
      return {
        success: false,
        message: '用户未登录',
      };
    }
  }
}
